#[derive(Debug)]
struct User{
    active: bool,
    username: String,
    email: String,
    sign_in_count: u32,
}


#[derive(Default)]
pub struct Rectangle {
    width: u32,
    height: u32,
}

//通过全部重新定义带所有权的字段，是定义的主要类型方式
//字段是引用类型
struct UserRef<'a>{
    active: &'a bool,
    username: &'a str,
    email: &'a str,
    sign_in_count: &'a u32
}

pub fn User_structure(){
    let active = true;
    let username = String::from("some username123");
    let email = String::from("someone@example.com");
    let user1 = User {
        active,
        username,
        email,
        sign_in_count: 1,
    };


    //partially moved 部分移动后导致所有权转移，下面打印user
    //是不允许的
    let email = user1.email;//String类型，因为要更改堆区的数据


    //println!("{:?}",user1);
    
}


//Rust并不是面向对象
//Rust 不是一门面向对象的语言，但是它确实有部分面向对象的特性。
// 而 Rust 承载面向对象特性的主要类型就是结构体
// Rust 有个关键字 impl 可以用来给结构体或其他类型实现方法，也就是关联在某个类型上的函数。
impl Rectangle {
    pub fn new(width: u32, height: u32) -> Self {   //from() ,etc and so on
        println!("create structure Rectangle");
        Rectangle {
            width,
            height,
        }
    }


    pub fn func_use(&self) -> u32{
        println!("usage");
        11u32
    }

    fn area(self) -> u32 {
        self.width * self.height
    }

    fn get_width(self) -> u32 {
        self.width
    }

    fn get_height(self) -> u32 {
        self.height
    }
}

const INITWIDTH: u32 = 50;
const INITHEIGHT: u32 = 30;

pub fn Structure_Instance() {
    let rect1 = Rectangle::new(INITWIDTH,INITHEIGHT);

    let aa = rect1.func_use();

    //两种实例化方式
    let rect2 = Rectangle::default();
    let rect3:Rectangle = Default::default();

    println!("{aa}");
}

//对于基本数据类型的方法拓展
trait Operate {
    fn plus(self) -> Self;
}

impl Operate for i8 {
    fn plus(self) -> Self {
        self + self
    }
}
